package com.cwt_taxi_xa.protocol.socket;

import android.util.Log;

import com.cwt_taxi_xa.constants.SPConstants;
import com.cwt_taxi_xa.model.LocalInfo;
import com.cwt_taxi_xa.model.RecorderInfo;
import com.cwt_taxi_xa.protocol.BusinessFactory;
import com.cwt_taxi_xa.protocol.DecoderSZ55aa;
import com.cwt_taxi_xa.protocol.DeviceBiz;
import com.cwt_taxi_xa.protocol.EncoderUtil;
import com.cwt_taxi_xa.timer.TimerCommon;
import com.cwt_taxi_xa.util.AppLog;
import com.cwt_taxi_xa.util.ByteArrayUtil;
import com.cwt_taxi_xa.util.DateUtil;
import com.cwt_taxi_xa.util.ExceptionUtil;
import com.cwt_taxi_xa.util.SPUtils;
import com.cwt_taxi_xa.util.StringUtil;
import com.cwt_taxi_xa.util.Tools;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;


/**
 * @author zr
 * 通讯平台协议编码
 */
public class Encoder {
	private static final String TAG = "Encoder";
	public int seq = 1;

	//获得发送序列号
	private int getSerialId(){
		if(seq > 65000){
			seq = 0;
		}
		seq++;
		return seq;
	}

	/**
	 * 终端注册
	 * @param province 省域ID
	 * @param city 市县域ID
	 * @param mid 制造商ID
	 * @param terminalId 终端ID
	 * @param carnumber 车牌号
	 * @param platecolor 车牌颜色
	 * @return
	 */
	public byte[] getTerminalRegistration(String province,String city,String mid,String terminalId,String carnumber,String platecolor){
		try {

			int len = (carnumber+"\0").getBytes("GBK").length;
			byte[] body = new byte[37+len];
			int dstPos = 0;
			//省域ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(Integer.parseInt(province),2)), 0, body, dstPos, 2);
			dstPos+=2;

			//市县域ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(Integer.parseInt(city.substring(2, 6)), 2)), 0, body, dstPos, 2);
			dstPos+=2;

			//制造商ID
			System.arraycopy(Tools.getByteToByte(mid, 5), 0, body, dstPos, 5);
			dstPos+=5;

			//终端型号
			String ddHHmmss = new SimpleDateFormat("yyyyMMddHHmmss").format(Calendar.getInstance().getTime()); // 获取系统当前时间
			System.arraycopy(Tools.getByteToByte(ddHHmmss, 20), 0, body, dstPos, 20);
			dstPos+=20;

			//终端id
			System.arraycopy(Tools.getByteToByte(terminalId, 7), 0, body, dstPos, 7);
			dstPos+=7;

			//车牌颜色
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(Integer.parseInt(platecolor),1)), 0, body, dstPos, 1);
			dstPos+=1;
			//车牌
			System.arraycopy((carnumber+"\0").getBytes("GBK"), 0, body, dstPos, len);
			byte[] bytes = getQhProtocol808(body, 0x0100);
			AppLog.e("终端注册："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 位置汇报数据补传
	 * @param hexStrData	0200消息体
	 * @return
	 */
	public byte[] getLocationInfoRepost(ArrayList<LocalInfo> hexStrData){
		try {
			byte[] body = new byte[25 * hexStrData.size()];
			int dstPos = 0;
			for(LocalInfo info:hexStrData){
				System.arraycopy(Tools.parseHexStr2Byte(info.getData()), 0, body, dstPos, 25);
				dstPos+=25;
			}

			byte[] bytes = getQhProtocol808(body, 0x0203);
			AppLog.i(TAG, "本地数据，位置汇报数据补传："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e), e);
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 存储音频检索应答	0x0805
	 * @param reseq 	应答流水号
	 * @param pkgSize 	总包数
	 * @param pkgCode 	当前包号
	 * @param list		照片数据list
	 * @return
	 */
	public byte[] multiRecordRetrievalResponse(int reseq, int pkgSize, int pkgCode, ArrayList<RecorderInfo> list, int listSize){
		try {
			int len = 21;
			// ID号总长度
			int mediaIdLength = 0;
			int recorderSize = 0;
			if(list != null && list.size() != 0){
				len = len + list.size()*22;
				mediaIdLength = list.size()*22;
				recorderSize = list.size();
			}
			AppLog.i(TAG, "录音列表上传，size = "+listSize+"; 共"+pkgSize+"包; 第"+(pkgCode+1)+"包"+"; subSize:"+recorderSize);
			byte[] body = new byte[len];
			int dstPos = 0;

			//应答流水号	UINT16	对应的车辆控制消息的流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reseq, 2)), 0, body, dstPos, 2);
			dstPos +=2;

			//车牌号	BYTE[6]	车牌号，ASCII 字符
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(9, 1)), 0, body, dstPos, 1);
			dstPos+=1;
			String carNmuber = DeviceBiz.getCarNumberSingleLetter();
			System.arraycopy(Tools.stringToByte(carNmuber), 0, body, dstPos, carNmuber.length());
			dstPos += 9;

			//数据包总数	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgSize, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//当前包包号	UINT32	，第一包数据为0
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgCode, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//当前包中含有的检索项个数	Byte
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(recorderSize, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			if(mediaIdLength != 0){
				for(int i = 0;i<list.size();i++){
					RecorderInfo info = list.get(i);
					//媒体ID号	UINT32[]	符合条件的文件ID列表
					int id = Integer.parseInt(list.get(i).getMediaId());
					System.arraycopy(Tools.sortToByte(Tools.int2Bytes(id, 4)), 0, body, dstPos, 4);
					dstPos +=4;
					// 文件大小	UINT32[]
					System.arraycopy(Tools.sortToByte(Tools.int2Bytes((int)info.getSize(), 4)), 0, body, dstPos, 4);
					dstPos +=4;
					// 开始时间	BCD[7]	如果是视频则为视频开始录制时间；如果是照片则为拍照时间
					System.arraycopy(Tools.str2Bcd("20"+info.getTime()), 0, body, dstPos, 7);
					dstPos +=7;
					// 结束时间	BCD[7]
					System.arraycopy(Tools.str2Bcd(info.getEtime()), 0, body, dstPos, 7);
					dstPos +=7;
					AppLog.i(TAG, "符合条件搜索条件的媒体ID，mediaID:"+id+"; stime:20"+info.getTime()+"; etime:"+info.getEtime());
				}
			}

			byte[] bytes = getQhProtocol808(body, 0x0805);
			AppLog.i(TAG, "存储音频检索应答	0x0805："+Tools.parseByte2HexStr(bytes));
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e), e);
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 10.3.5.41音视频上传		消息ID：0x0806
	 * @param serialId	流水号
	 * @param mediaId	多媒体ID
	 * @param pkgCount	包数量
	 * @param pkgNum	包序号
	 * @param fileHead	音频数据头
	 * @param data		数据
	 * @return
	 */
	public byte[] multiRecordUpload(int serialId, int mediaId,int pkgCount,int pkgNum,
										   byte[] fileHead, byte[] data){
		try {
			int len = 24;
			if(data != null){
				if(pkgNum == 0){
					len += (data.length + 128);
				}else{
					len += data.length;
				}
			}

			byte[] body = new byte[len];
			int dstPos = 0;

			// 存储图像/音视频上传命令流水号	UINT16
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(serialId, 2)), 0, body, dstPos, 2);
			dstPos +=2;
			// 音视频ID	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(mediaId, 4)), 0, body, dstPos, 4);
			dstPos +=4;
			//车牌号	BYTE[6]	车牌号，ASCII 字符
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(9, 1)), 0, body, dstPos, 1);
			dstPos+=1;
			String carNmuber = DeviceBiz.getCarNumberSingleLetter();
			System.arraycopy(Tools.stringToByte(carNmuber), 0, body, dstPos, carNmuber.length());
			dstPos += 9;
			// 位置/音视频数据大小	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgCount, 4)), 0, body, dstPos, 4);
			dstPos +=4;
			// 起始地址	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgNum, 4)), 0, body, dstPos, 4);
			dstPos +=4;
			// 位置/音视频图像数据包
			if(data != null){
				if(pkgNum == 0 && fileHead != null){
					System.arraycopy(fileHead, 0, body, dstPos, fileHead.length);
					dstPos += 128;
				}
				System.arraycopy(data, 0, body, dstPos, data.length);
				dstPos +=data.length;
			}

			byte[] bytes = getQhProtocol808(body, 0x0806);
			AppLog.i(TAG, "音视频上传		消息ID：0x0806："+Tools.parseByte2HexStr(bytes));
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e), e);
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 终端鉴权
	 * @param result 登录原因	BYTE
	 * 							1.开机启动登陆
	 * 							2.重启登陆(无法区分重启和开机时统一使用开机)
	 * 							3.掉线登陆
	 * 							4.登陆（无法区分原因时
	 * 							5-255.预留
	 * @return
	 */
	//	public static byte[] getAuthentication(int result){
	//		try {
	//			int dstPos = 0;
	//			byte[] head = new byte[39];
	//			//鉴权码		STRING	鉴权码，当前版本不实现，预留
	//			//版本号		BCD[2]	软件版本号，1.0.0，填入0x0100
	//			String versionCode = VersionBiz.getVersionName(CarCallApplication.getInstance());
	//			versionCode = versionCode.replaceAll("\\.", "");
	//			System.arraycopy(Tools.str2Bcd("0"+versionCode), 0, head, dstPos, 2);
	//			dstPos += 2;
	//			//时间戳		BCD[6]	YY-MM-DD-hh-mm-ss
	//			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, head, dstPos, 6);
	//			dstPos += 6;
	//			//SIM卡号	BCD[20]	SIM卡卡号
	//			String sim = SPutil.defaultPref().getString("hytdsim", "0000000000000000000000000000000000000000");
	//			sim = "0000000000000000000000000000"+sim;
	//			System.arraycopy(Tools.str2Bcd(sim), 0, head, dstPos, 20);
	//			dstPos += 20;
	//			//设备编号	BCD[10]	设备硬件编号
	//			String firmVersionCode = "00000000000000000000";
	//			if(!StringUtil.isNull(CarCallApplication.getInstance().firmVersionCode)){
	//				firmVersionCode = CarCallApplication.getInstance().firmVersionCode+"0000000000000000";
	//			}
	//			System.arraycopy(Tools.str2Bcd(firmVersionCode), 0, head, dstPos, 10);
	//			dstPos += 10;
	//			//登录原因	BYTE	1.开机启动登陆	2.重启登陆(无法区分重启和开机时统一使用开机)	3.掉线登陆	4.登陆（无法区分原因时	5-255.预留
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result,1)), 0, head, dstPos, 1);
	//
	//			byte[] bytes = getQhProtocol808(head, 0x0102);
	//			return bytes;
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 终端通用应答
	 * @param serialCode	应答流水号		UINT16	对应的中心消息的流水号
	 * @param msgid 		应答ID		UINT16	对应的中心消息的ID
	 * @param result 		结果			UINT8	0:成功/确认	1:失败	2:消息有误
	 * @return
	 */
	public byte[] getTerminalGeneralResponse(int serialCode, int msgid, int result){
		try {
			byte[] head = new byte[5];
			int dstPos = 0;
			//应答流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(serialCode,2)), 0, head, dstPos, 2);
			dstPos+=2;
			//应答id
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(msgid,2)), 0, head, dstPos, 2);
			dstPos+=2;
			//结果
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result,1)), 0, head, dstPos, 1);

			byte[] bytes = getQhProtocol808(head, 0x0001);
			AppLog.i("终端通用应答："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 心跳
	 * @return
	 */
	public byte[] getHeartbeat(){
		try {
			byte[] bytes = getQhProtocol808(null, 0x0002);
			AppLog.i("发送心跳");
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 位置信息汇报
	 * @return
	 */
	public byte[] getLocationInformation(){
		try {
			//位置数据
			byte [] locationbyte = EncoderUtil.getLocationInformationByte();
			byte[] bytes = getQhProtocol808(locationbyte, 0x0200);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 位置信息汇报
	 * @return
	 */
	public byte[] getLocationInformation(byte [] locationByte){
		try {
			//位置数据
			byte[] bytes = getQhProtocol808(locationByte, 0x0200);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 位置信息应答
	 * //@param locationInfo
	 * @return
	 */
	public byte[] getLocationInformationAnswer(int reseq){
		try {
			byte[] locationByte = EncoderUtil.getLocationInformationByte();
			byte[] body = new byte[2+locationByte.length];
			int dstPos = 0;
			//应答流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reseq, 2)), 0, body, dstPos, 2);
			dstPos+=2;

			//位置定位数据
			System.arraycopy(locationByte, 0, body, dstPos, locationByte.length);

			byte[] bytes = getQhProtocol808(body, 0x0201);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.5	数据订阅	0x000F
	 * @param id		消息类型	UINT16
	 * @param dataType	二级数据类型	UINT32	无则填-1
	 * @return
	 */
	public byte[] getDataSubscription(int id, int dataType){
		try {
			int len = 2;
			if(dataType != -1){
				len = 6;
			}
			byte[] body = new byte[len];
			int dstPos = 0;
			// 消息类型
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(id, 2)), 0, body, dstPos, 2);
			dstPos+=2;

			if(dataType != -1){
				System.arraycopy(Tools.sortToByte(Tools.int2Bytes(dataType, 4)), 0, body, dstPos, 4);
			}

			byte[] bytes = getQhProtocol808(body, 0X000F);
			AppLog.i("数据订阅	0x000F："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.48	上班签到	0x0B03
	 * @param meterPowerOnData		计价器开机信息
	 * @return
	 */
	public byte[] getCheckIn(byte[] meterPowerOnData,int count){
		try {
			byte[] locationInfo = EncoderUtil.getLocationInformationByte();
			byte[] head = new byte[meterPowerOnData.length + locationInfo.length + 11];
			int dstPos = 0;
			//			位置基本信息
			System.arraycopy(locationInfo, 0, head, dstPos, locationInfo.length);
			dstPos += locationInfo.length;
			/*//			计价器开机信息(单位代码、司机代码、车牌号)
			System.arraycopy(meterPowerOnData, 0, head, dstPos, meterPowerOnData.length);
			dstPos += meterPowerOnData.length;*/
			//			计价器开机信息(单位代码、司机代码、车牌号)
			System.arraycopy(meterPowerOnData, 0, head, dstPos, meterPowerOnData.length-6);
			dstPos += meterPowerOnData.length-6;


			String carNumber = SPUtils.getParamString(SPConstants.SPK_carcode, SPConstants.SPV_carcode);
			carNumber = carNumber.replaceAll("测", "");
			carNumber = carNumber.replaceAll("灯", "");
			carNumber = carNumber.replaceAll("陕", "");
			System.arraycopy(Tools.stringToByte(carNumber), 0, head, dstPos, 6);
			dstPos += 6;
			// 计价器开机时间
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df6)), 0, head, dstPos, 7);
			dstPos += 7;
			// 总运营次数 uint32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(count, 4)), 0, head, dstPos, 4);
			dstPos += 4;

			byte[] bytes = getQhProtocol808(head, 0x0B03);
			AppLog.i("上班签到	0x0B03："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.48	上班签到	0x0B03
	 * @param meterPowerOnData		计价器开机信息
	 * @return
	 */
	public byte[] getCheckIn(byte[] meterPowerOnData){
		try {
			byte[] locationInfo = EncoderUtil.getLocationInformationByte();
			byte[] head = new byte[meterPowerOnData.length + locationInfo.length];
			int dstPos = 0;
			//			位置基本信息
			System.arraycopy(locationInfo, 0, head, dstPos, locationInfo.length);
			dstPos += locationInfo.length;
			//			计价器开机信息
			System.arraycopy(meterPowerOnData, 0, head, dstPos, meterPowerOnData.length);
			dstPos += meterPowerOnData.length;

			byte[] bytes = getQhProtocol808(head, 0x0B03);
			AppLog.i("上班签到	0x0B03："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.49	下班签退	0B04
	 * @param meterPowerOffData		计价器关机信息数据
	 * @return
	 */
	public byte[] getCheckOut(byte[] meterPowerOffData){
		try {
			byte[] locationInfo = EncoderUtil.getLocationInformationByte();
			byte[] head = new byte[meterPowerOffData.length+locationInfo.length + 1];
			int dstPos = 0;
			//			位置基本信息
			System.arraycopy(locationInfo, 0, head, dstPos, locationInfo.length);
			dstPos += locationInfo.length;
			//			计价器关机信息数据
			System.arraycopy(meterPowerOffData, 0, head, dstPos, meterPowerOffData.length);
			dstPos += meterPowerOffData.length;
			// 签退方式	BYTE	0x00：正常签退；0x01：强制签退
			System.arraycopy(Tools.parseHexStr2Byte("00"), 0, head, dstPos, 1);


			byte[] bytes = getQhProtocol808(head, 0x0B04);
			AppLog.i("下班签退	0x0B04："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.48	上班签到	0x0A00
	 * //@param companyCode			单位代码
	 * //@param driverCode			司机代码
	 * //@param carCode				车辆自编号
	 * //@param businessTotalCount	总营运次数
	 * //@return
	 */
	public byte[] getPicHeat(int id, int filesize){
		try {
			byte[] body = new byte[128];
			int dstPos = 0;

			// 0	终端ID号	BCD[5]	MCU终端的ID号
			System.arraycopy(Tools.str2Bcd(DeviceBiz.getDeviceCode().substring(2)), 0, body, dstPos, 5);
			dstPos+=5;
			// 5	编码方式	BCD	各厂商自定义，需根据终端ID号中的厂商编码及编码方式 提供相应的解压缩接口
			dstPos+=1;
			// 6	车牌号	STRING[10]	车牌号，不足长度以’\0’填充
			String carNumber = DeviceBiz.getCarNumber();
			while(carNumber.length()<10){
				carNumber += "\0";
			}
			byte[] carNumberByte = carNumber.getBytes("GBK");
			System.arraycopy(carNumberByte, 0, body, dstPos, carNumberByte.length);
			dstPos+=10;
			// 16	营运ID	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(id, 4)), 0, body, dstPos, 4);
			dstPos+=4;
			// 20	0：进入重车拍照；1：服务评价拍照；2：报警拍照；3：中心主动拍照
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(3, 1)), 0, body, dstPos, 1);
			dstPos+=1;
			// 21	时间	BCD[6]	北京时间YYMMDDhhmmss
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, body, dstPos, 6);
			dstPos+=6;
			// 27	纬度	UINT32	0.0001’
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(Tools.getSZLocation(EncoderUtil.getCurretnLat()), 4)), 0, body, dstPos, 4);
			dstPos+=4;
			// 31	经度	UINT32	0.0001’
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(Tools.getSZLocation(EncoderUtil.getCurretnLng()), 4)), 0, body, dstPos, 4);
			dstPos+=4;
			// 50	文件在ISU中的文件ID号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(id, 4)), 0, body, dstPos, 4);
			dstPos+=4;
			// 54	UINT32	数据的大小，单位：字节
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(filesize, 4)), 0, body, dstPos, 4);
			dstPos+=4;
			// 58	RFU		保留为0
			return body;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e), e);
			e.printStackTrace();
			return null;
		}
	}


	/**
	 * 3.2.48	上班签到	0x0A00
	 * @param companyCode			单位代码
	 * @param driverCode			司机代码
	 * @param carCode				车辆自编号
	 * @param businessTotalCount	总营运次数
	 * @return
	 */
	/*public byte[] getCheckIn(String companyCode, String driverCode,
			String carCode, int businessTotalCount){
		try {
			byte[] locationInfo = QHEncoderUtil.getLocationInformationByte();
			byte[] head = new byte[27+locationInfo.length];
			int dstPos = 0;
			//			位置基本信息
			System.arraycopy(locationInfo, 0, head, dstPos, locationInfo.length);
			dstPos += locationInfo.length;
			//			单位代码	BCD[5]
			System.arraycopy(Tools.str2Bcd(companyCode), 0, head, dstPos, 5);
			dstPos += 5;
			//			司机代码	BCD[6]
			System.arraycopy(Tools.str2Bcd(driverCode), 0, head, dstPos, 6);
			dstPos += 6;
			//			车辆自编号	BYTE[6]
			System.arraycopy(Tools.str2Bcd(carCode), 0, head, dstPos, 6);
			dstPos += 6;
			//			时间	BCD[6]
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, head, dstPos, 6);
			dstPos += 6;
			//			总营运次数	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(businessTotalCount,4)), 0, head, dstPos, 4);
			dstPos+=4;

			byte[] bytes = getQhProtocol808(head, 0x0A00);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}*/

	/**
	 * 3.2.49	下班签退	0x0A01
	 * @param companyCode				单位代码
	 * @param driverCode				司机代码
	 * @param carCode					车辆自编号
	 * @param checkinTime				上班时间
	 * @param onDutyMileage				当班公里
	 * @param onDutyBusinessMileage		当班营运公里
	 * @param businessTime				计时时间
	 * @param totalAmount				总计金额
	 * @param cardAmount				卡收金额
	 * @param carCount					卡次
	 * @param intervalMileage			班间公里
	 * @param totalMileage				总计公里
	 * @param totalBusinessMileage		总营运公里
	 * @param price						单价
	 * @param businessTotalCount		总营运次数
	 * @param totalWaitTime				总等待时间
	 * @return
	 *//*
	public byte[] getCheckOut(String companyCode, String driverCode,
			String carCode, String checkinTime, double onDutyMileage,double onDutyBusinessMileage,
			String businessTime, double totalAmount, int cardAmount, int carCount,
			double intervalMileage, double totalMileage, double totalBusinessMileage, double price,
			int businessTotalCount, String totalWaitTime){
		try {
			byte[] locationInfo = QHEncoderUtil.getLocationInformationByte();
			byte[] head = new byte[67+locationInfo.length];
			int dstPos = 0;
			//			位置基本信息
			System.arraycopy(locationInfo, 0, head, dstPos, locationInfo.length);
			dstPos += locationInfo.length;
			//			单位代码	BCD[5]
			System.arraycopy(Tools.str2Bcd(companyCode), 0, head, dstPos, 5);
			dstPos += 5;
			//			司机代码	BYTE[6]
			System.arraycopy(Tools.str2Bcd(driverCode), 0, head, dstPos, 6);
			dstPos += 6;
			//			车辆自编号	BYTE[6]
			System.arraycopy(Tools.str2Bcd(carCode), 0, head, dstPos, 6);
			dstPos += 6;
			//			脉冲数	BCD[2]	格式为XXXX，最大9999，暂时填0
			System.arraycopy(Tools.str2Bcd("0"), 0, head, dstPos, 2);
			dstPos += 2;
			//			上班时间	BCD[6]
			System.arraycopy(Tools.str2Bcd(checkinTime), 0, head, dstPos, 6);
			dstPos += 6;
			//			下班时间	BCD[6]
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, head, dstPos, 6);
			dstPos += 6;
			//			当班公里	BCD[3]	格式为XXXXX.X公里
			System.arraycopy(Tools.str2Bcd(String.valueOf(onDutyMileage)), 0, head, dstPos, 3);
			dstPos += 3;
			//			当班营运公里	BCD[3]	格式为XXXXX.X公里
			System.arraycopy(Tools.str2Bcd(String.valueOf(onDutyBusinessMileage)), 0, head, dstPos, 3);
			dstPos += 3;
			//			车次	BCD[2]	格式为XXXX，最大9999（保留，填0）
			System.arraycopy(Tools.str2Bcd("0"), 0, head, dstPos, 2);
			dstPos += 2;
			//			计时时间	BCD[3]	计费时间 hh-mm-ss
			System.arraycopy(Tools.str2Bcd(businessTime), 0, head, dstPos, 3);
			dstPos += 3;
			//			总计金额	BCD[3]	格式XXXXX.X元
			System.arraycopy(Tools.str2Bcd(String.valueOf(totalAmount)), 0, head, dstPos, 3);
			dstPos += 3;
			//			卡收金额	BCD[3]	格式XXXXX.X元
			System.arraycopy(Tools.str2Bcd(String.valueOf(cardAmount)), 0, head, dstPos, 3);
			dstPos += 3;
			//			卡次	BCD[2]	格式为XXXX，最大9999
			System.arraycopy(Tools.str2Bcd(String.valueOf(carCount)), 0, head, dstPos, 2);
			dstPos += 2;
			//			班间公里	BCD[2]	格式XXX.X公里（上一班签退到本班签到的公里数）
			System.arraycopy(Tools.str2Bcd(String.valueOf(String.valueOf(intervalMileage))), 0, head, dstPos, 2);
			dstPos += 2;
			//			总计公里	BCD[3]	格式为XXXXX.X公里（计价器安装后累积的里程）
			System.arraycopy(Tools.str2Bcd(String.valueOf(totalMileage)), 0, head, dstPos, 3);
			dstPos += 3;
			//			总营运公里	BCD[3]	格式为XXXXX.X公里（计价器安装后累积的里程）
			System.arraycopy(Tools.str2Bcd(String.valueOf(totalBusinessMileage)), 0, head, dstPos, 3);
			dstPos += 3;
			//			单价	BCD[2]	格式XX.XX元
			System.arraycopy(Tools.str2Bcd(String.valueOf(price)), 0, head, dstPos, 2);
			dstPos += 2;
			//			总营运次数	UINT32	高位在前，低位在后
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(businessTotalCount,4)), 0, head, dstPos, 4);
			dstPos+=4;
			//			总等待时间	BCD[3]	等待时间 hh-mm-ss
			System.arraycopy(Tools.str2Bcd(String.valueOf(totalWaitTime)), 0, head, dstPos, 3);
			dstPos += 3;

			byte[] bytes = getQhProtocol808(head, 0x0A01);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}*/

	/**
	 * 上班签到信息上传
	 * @param
	 * @return
	 *//*
	public byte[] getSignedInfo(byte[] meterPowerOnData){
		try {
			byte[] location = SZEncoderUtil.getLocationInformationByte();
			byte[] body = new byte[meterPowerOnData.length+location.length];
			int dstPos = 0;
			System.arraycopy(location, 0, body, dstPos, location.length);
			dstPos += location.length;
			System.arraycopy(meterPowerOnData, 0, body, dstPos, meterPowerOnData.length);
			dstPos += meterPowerOnData.length;
			byte[] bytes = getQhProtocol808(body, 0x0B03);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}*/

	/**
	 * 下班签退信息上传
	 * @param
	 * @return
	 */
	public byte[] getSignBackInfo(byte[] meterPowerOffData){
		try {
			byte[] location = EncoderUtil.getLocationInformationByte();
			byte[] body = new byte[meterPowerOffData.length+location.length];
			int dstPos = 0;
			System.arraycopy(location, 0, body, dstPos, location.length);
			dstPos += location.length;
			System.arraycopy(meterPowerOffData, 0, body, dstPos, meterPowerOffData.length);
			dstPos += meterPowerOffData.length;
			byte[] bytes = getQhProtocol808(body, 0x0B04);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 终端消息应答
	 * @param msgid 消息ID
	 * @param result 结果	BYTE	0：成功/确认；1：失败；2：消息有误；3：不支持
	 * @return
	 */
	public byte[] getTerminalResponse(int msgid,int result){
		try {
			byte[] head = new byte[5];
			int dstPos = 0;
			//应答流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(getSerialId(),2)), 0, head, dstPos, 2);
			dstPos+=2;
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(msgid,2)), 0, head, dstPos, 2);
			dstPos+=2;
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result,1)), 0, head, dstPos, 1);

			byte[] bytes = getQhProtocol808(head, msgid);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 运营数据上传
	 * @param valuation				评价选项
	 * 		0x00,没有做出评价；0x01,满意；0x02,一般；0x03，不满意；0x04，投诉
	 * @param orderId	评价选项扩展
	 * @return
	 */
	public byte[] getBusinessDataUplpad( int valuation, int orderId){
		try {
			byte[] aboardLocationData = BusinessFactory.aboardLocationData;
			if(aboardLocationData == null){
				aboardLocationData = EncoderUtil.getLocationInformationByte();
			}
			byte[] goOffLocationData = BusinessFactory.goOffLocationData;
			if(goOffLocationData == null){
				goOffLocationData = EncoderUtil.getLocationInformationByte();
			}
			byte[] meterSingleBusinessData = BusinessFactory.meterSingleBusinessData;
			int meterlen = 0;
			if(meterSingleBusinessData != null){
				meterlen = meterSingleBusinessData.length;
			}
			byte[] head = new byte[15 + aboardLocationData.length + goOffLocationData.length + meterlen];
			int dstPos = 0;


			// 上车时间	BCD[5]	格式为YY-MM-DD-hh-mm
			int sTimeIndex = 15 + 6 + 16 + 19;
			String sTime = Tools.bcd2Str(Tools.byteTobyte(meterSingleBusinessData, sTimeIndex, 5));
			//yyyyMMddHHmmss
			sTime = "20" + sTime + "00";

			//			空转重时位置基本信息
			System.arraycopy(aboardLocationData, 0, head, dstPos, aboardLocationData.length);
			dstPos+=aboardLocationData.length;
			//			重转空时位置基本信息
			System.arraycopy(goOffLocationData, 0, head, dstPos, goOffLocationData.length);
			dstPos+=goOffLocationData.length;
			//			营运ID	UINT32
			System.arraycopy(BusinessFactory.getBusinessId(sTime), 0, head, dstPos, 4);
			dstPos+=4;
			//			评价ID	UINT32
			String evaluateTime = DateUtil.getTodayDate(DateUtil.df6);
			byte[] valuationId = BusinessFactory.getEvaluateId(evaluateTime);
			if(valuation == 0){
				valuationId = new byte[4];
			}
			System.arraycopy(Tools.sortToByte(valuationId), 0, head, dstPos, 4);
			dstPos+=4;
			//			评价选项	UINT8
			System.arraycopy(Tools.int2Bytes(valuation,1), 0, head, dstPos, 1);
			dstPos+=1;
			//			评价选项扩展	UINT16
			System.arraycopy(Tools.parseHexStr2Byte("0000"), 0, head, dstPos, 2);
			dstPos+=2;
			// 订单ID	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(orderId, 4)), 0, head, dstPos, 4);
			dstPos+=4;
			//			计价器营运数据
			if(meterSingleBusinessData!=null){
				System.arraycopy(BusinessFactory.meterSingleBusinessData, 0, head, dstPos, meterlen);
			}

			byte[] bytes = getQhProtocol808(head, 0x0B05);
//			AppLog.e("运营数据不准测试---运营数据上传："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
//			AppLog.e("运营数据不准测试---运营数据上传失败");
			try {
				TimerCommon.sendLog(3, "Encoder.getBusinessDataUplpad返回空\n"
						+  DecoderSZ55aa.lastJJQData==null?"":Tools.parseByte2HexStr2(DecoderSZ55aa.lastJJQData));
			} catch (Exception e2) {
				try {
					TimerCommon.sendLog(3, "Encoder.getBusinessDataUplpad返回空...提交计价器数据失败");
				} catch (Exception e3) {
				}
			}
			return null;
		}
	}

	/**
	 * 3.2.52	上行透传  0x0900
	 * @param dataType	数据类型				1	金融刷卡数据	2-255	预留
	 * @param vendorId	厂商标识（二级类型）		1	天府通	2	和信通	3-255	预留
	 * @param data		数据包	UINT8[]
	 * @return
	 */
	public byte[] getUplinkPassthrough(int dataType, int vendorId, byte[] data){
		try {
			int dstPos = 0;
			int len = 5;
			if(data != null){
				len = len + data.length;
			}
			byte[] head = new byte[len];
			//			数据类型	UINT8
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(dataType,1)), 0, head, dstPos,1);
			dstPos+=1;
			//			厂商标识（二级类型）	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(vendorId,4)), 0, head, dstPos,4);
			dstPos+=4;
			if(data != null){
				//			数据包	UINT8[]
				System.arraycopy(data, 0, head, dstPos,data.length);
			}
			byte[] bytes = getQhProtocol808(head, 0x0900);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 外围设备指令上行透传
	 * @param TypeID    4-LED显示屏              5-智能顶灯
	 * @param vendorId	厂商标识
	 * @param midType	命令类型
	 * @param data		数据包	UINT8[]
	 * @return
	 */
	public byte[] getUplinkPassthrough(int TypeID, int vendorId, int midType, byte[] data){
		try {
			int dstPos = 0;
			int len = 4 + data.length;
			byte[] head = new byte[len];
			//	UINT8
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(TypeID,1)), 0, head, dstPos,1);
			dstPos+=1;
			//	厂商标识（二级类型）	UINT8
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(vendorId,1)), 0, head, dstPos,1);
			dstPos+=1;
			//	命令类型 	UINT16
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(midType,2)), 0, head, dstPos,2);
			dstPos+=2;
			//			数据包	UINT8[]
			System.arraycopy(data, 0, head, dstPos,data.length);
			byte[] bytes = getQhProtocol808(head, 0x0B10);

			AppLog.saveTxt("getUplinkPassthrough："+Tools.parseByte2HexStr(bytes));

//			return Tools.parseHexStr2Byte("7E0B10003D1010000156250010050C000045003300C054494D4500430010000054494D45120B1B030B2A2D01FD7D01027D0102FFB99823120B1B030B2A2D00000000000000036AC570E5907E");
//			return Tools.parseHexStr2Byte("7E0B10003D1010000156250010050C00007D0245003300C054494D4500430010000054494D45120B1B030B2A2D01FD7D01027D0102FFB99823120B1B030B2A2D00000000000000036AC570E57D02907E");
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 *	实时音视频传输请求应答
	 * @param result	结果	0：成功	1：失败	2：不支持	3：会话结束
	 * @return
	 */
	//	public byte[] getMediaTransferResponder(int result){
	//		try {
	//			int dstPos = 0;
	//			byte[] head = new byte[7];
	//			//	UINT16	对应请求命令的流水号
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(RecorderBiz.serialId8804,2)), 0, head, dstPos,2);
	//			dstPos+=2;
	//			//	UINT32	多媒体数据ID
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(RecorderBiz.mediaId8804,4)), 0, head, dstPos,4);
	//			dstPos+=4;
	//			//	byte
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result,1)), 0, head, dstPos,1);
	//			dstPos+=1;
	//			byte[] bytes = getQhProtocol808(head, 0x0804);
	//			return bytes;
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 3.2.53	电子服务证请求  0x0D00
	 * @param	serviceCode	司机代码
	 * @return
	 */
	//	public byte[] getDriverElectronicalInfo(DriverInfo info){
	//		try {
	//			String driverCode = info.getDriverCode();
	//			String version = info.getElectronicalVersion();
	//			// serviceCode = "00000020463";
	//			// version = "140305093247";
	//
	//			byte[] head = new byte[62];
	//			int dstPos = 0;
	//			//			司机代码	BCD[6]	车辆自编号+司机编码，6位，不足的前面补0
	//			while(driverCode.length()<12){
	//				driverCode = "0"+driverCode;
	//			}
	//
	//			System.arraycopy(Tools.str2Bcd(driverCode), 0, head, dstPos, 6);
	//			dstPos += 6;
	//			//			驾驶员唯一编号	BYTE[50]	预留，全部填0
	//			System.arraycopy(new byte[50], 0, head, dstPos, 50);
	//			dstPos += 50;
	//			//	BCD[6]	YYMMDDhhmmss，当前终端中电子服务证版本
	//			System.arraycopy(Tools.str2Bcd(version), 0, head, dstPos, 6);
	//			dstPos += 6;
	//			byte[] bytes = getQhProtocol808(head, 0x0D00);
	//			AppLog.i("3.2.53	电子服务证请求  0x0D00："+Tools.parseByte2HexStr(bytes));
	//			return bytes;
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 3.2.60	密钥更新请求 	0x0D01
	 * @param	keyType			密钥类型	UINT8	0：PSAM  1：ESAM
	 * @param	fileCode		文件标识符	UINT16
	 * @param	random			随机数	UINT32
	 * @param	brotherCode		同步号	UINT32
	 * @return
	 */
	public byte[] getKeyUpdate(int keyType, int fileCode, int random, int brotherCode){
		try {
			byte[] head = new byte[11];
			int dstPos = 0;
			//			密钥类型	UINT8	0：PSAM  1：ESAM
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(keyType,1)), 0, head, dstPos,1);
			dstPos += 1;
			//			文件标识符	UINT16
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(fileCode,2)), 0, head, dstPos,2);
			dstPos += 2;
			//			随机数	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(random,4)), 0, head, dstPos,4);
			dstPos += 4;
			//			同步号	UINT32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(brotherCode,4)), 0, head, dstPos,4);
			dstPos += 4;

			byte[] bytes = getQhProtocol808(head, 0x0D01);
			AppLog.i("3.2.60	密钥更新请求   0x0D01："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.61	密钥更新结果 	0x0D02
	 * @param	result 更新结果	UINT8	0：失败 1：成功
	 * @param	keyType 密钥类型	UINT8	0：PSAM 1：ESAM
	 * @param	keyVersion 密钥版本	BCD[7]	YYYYMMDDhhmmss
	 * @param	brotherCode 同步号	UINT32	与密钥内容下发中的一致
	 * @return
	 */
	public byte[] getKeyUpdateResult(int result, int keyType, String keyVersion, int brotherCode){
		try {
			byte[] head = new byte[11];
			int dstPos = 0;
			//	更新结果	UINT8	0：失败 1：成功
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result,1)), 0, head, dstPos,1);
			dstPos += 1;
			//	密钥类型	UINT8	0：PSAM 1：ESAM
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(keyType,2)), 0, head, dstPos,2);
			dstPos += 2;
			//	密钥版本	BCD[7]	YYYYMMDDhhmmss
			System.arraycopy(Tools.str2Bcd(keyVersion), 0, head, dstPos, 7);
			dstPos += 7;
			//	同步号	UINT32	与密钥内容下发中的一致
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(brotherCode,4)), 0, head, dstPos,4);
			dstPos += 4;

			byte[] bytes = getQhProtocol808(head, 0x0D02);
			AppLog.i("3.2.61	密钥更新结果   0x0D02："+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.55	校时请求  0x0004
	 * @return
	 */
	/*public byte[] getSystemTimeAdjusting(){
		try {
			byte[] head = new byte[6];
			int dstPos = 0;
			//终端本机时间	BCD[6]	YY-MM-DD-hh-mm-ss
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, head, dstPos, 6);

			byte[] bytes = getQhProtocol808(head, 0x0004);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}*/

	/**
	 * 3.2.11	终端自检报告
	 * @return
	 */
	//	public byte[] getTerminalSelfChenking(){
	//		try {
	//			SharedPreferences pref = SPutil.defaultPref();
	//			byte[] head = new byte[7+15+18];
	//			int dstPos = 0;
	//			//	自检时间	BCD[6]	YYMMDDhhmmss
	//			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, head, dstPos, 6);
	//			dstPos+=6;
	//			//	自检报告总数	BYTE
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(5,1)), 0, head, dstPos, 1);
	//			dstPos+=1;
	//			/** 自检报告列表		见表23*/
	//
	//			//	0x0001	BCD[3]	热黑名单版本号，YYMMDD
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(0x0001,2)), 0, head, dstPos, 2);
	//			dstPos+=2;
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(3,1)), 0, head, dstPos, 1);
	//			dstPos+=1;
	//			String hotBlack = pref.getString(PrefConstants.HOT_BLACK_LIST_VERSION_CODE, "150701");
	//			System.arraycopy(Tools.str2Bcd(hotBlack), 0, head, dstPos, 3);
	//			dstPos+=3;
	//			//	0x0002	BCD[3]	冷黑名单版本号，YYMMDD
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(0x0002,2)), 0, head, dstPos, 2);
	//			dstPos+=2;
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(3,1)), 0, head, dstPos, 1);
	//			dstPos+=1;
	//			String coolBlack = pref.getString(PrefConstants.COOL_BLACK_LIST_VERSION_CODE, "150701");
	//			System.arraycopy(Tools.str2Bcd(coolBlack), 0, head, dstPos, 3);
	//			dstPos+=3;
	//			/**	0x0003	BCD[4]	公钥信息文件版本号 	XXYYMMDD
	//			 * 									XX:01-天府通公钥；02-和信通公钥
	//			 * 									YYMMDD：版本号*/
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(0x0003,2)), 0, head, dstPos, 2);
	//			dstPos+=2;
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(4,1)), 0, head, dstPos, 1);
	//			dstPos+=1;
	//			String keyInfoFile = pref.getString(PrefConstants.KEY_INFO_FILE_VERSION_CODE, "01150701");
	//			System.arraycopy(Tools.str2Bcd(keyInfoFile), 0, head, dstPos, 4);
	//			dstPos+=4;
	//			/**	0x0004	BCD[4]	IC卡参数文件版本号，XXYYMMDD
	//			 *									XX:01-天府通IC卡参数；02-和信通IC卡参数
	//			 * 									YYMMDD：版本号
	//			 * */
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(0x0004,2)), 0, head, dstPos, 2);
	//			dstPos+=2;
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(4,1)), 0, head, dstPos, 1);
	//			dstPos+=1;
	//			String icCard = pref.getString(PrefConstants.IC_CARD_PARAMS_FILE_VERSION_CODE, "01150701");
	//			System.arraycopy(Tools.str2Bcd(icCard), 0, head, dstPos, 4);
	//			dstPos+=4;
	//			/**	0x0005	BCD[4]	密钥版本号，XXYYMMDD
	//			 * 							 XX:01-天府通密钥；02-和信通密钥
	//			 * 							 YYMMDD：版本号*/
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(0x0005,2)), 0, head, dstPos, 2);
	//			dstPos+=2;
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(4,1)), 0, head, dstPos, 1);
	//			dstPos+=1;
	//			String key = pref.getString(PrefConstants.KEY_VERSION_CODE, "01150701");
	//			System.arraycopy(Tools.str2Bcd(key), 0, head, dstPos, 4);
	//			dstPos+=4;
	//
	//			byte[] bytes = getQhProtocol808(head, 0x0106);
	//			return bytes;
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 3.2.10	升级结果报告
	 * @param deviceType 设备类型	UINT8
	 * @param vendorId	厂商标识	UINT8
	 * @param firmVersionCode 1	硬件版本号	BCD
	 * @param softVersionCode 1	软件版本号	BCD[2]	第一个字节为主版本号；第二个字节为副版本号
	 * @param result	升级结果	UINT8	0：软件版本号一致，无需升级
	 * 							1：升级成功
	 * 							2：升级失败
	 * 							3：厂商标识不一致
	 * 							4：硬件版本号不一致
	 * 							5：下载文件升级失败
	 * 							6：升级服务器主动取消升级
	 * 							7：设备主动放弃升级（非自身程序）
	 * @return
	 */
	public byte[] getUpdateVersionResult(int deviceType, int vendorId,
												String firmVersionCode, String softVersionCode, int result){
		try {
			byte[] head = new byte[6];
			int dstPos = 0;
			//			0	设备类型	UINT8
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(deviceType,1)), 0, head, dstPos, 1);
			dstPos += 1;
			//			1	厂商标识	UINT8
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(vendorId,1)), 0, head, dstPos, 1);
			dstPos += 1;
			//			2	硬件版本号	BCD
			System.arraycopy(Tools.str2Bcd(firmVersionCode), 0, head, dstPos, 1);
			dstPos += 1;
			//			3	软件版本号	BCD[2]	第一个字节为主版本号；第二个字节为副版本号
			System.arraycopy(Tools.str2Bcd(softVersionCode), 0, head, dstPos, 2);
			dstPos += 2;
			//			5	升级结果	UINT8	0：软件版本号一致，无需升级
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result,1)), 0, head, dstPos, 1);
			dstPos += 1;
			byte[] bytes = getQhProtocol808(head, 0x0105);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.7	查询终端参数
	 * @param serialId	应答流水号		UINT16	对应的中心消息的流水号
	 * @param data			参数
	 * @return
	 */
	public byte[] getQueryTerminalParams(int serialId, byte[] data){
		try {
			int len = 2;
			if(data != null){
				len += data.length;
			}

			byte[] head = new byte[len];
			int dstPos = 0;
			//应答流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(serialId,2)), 0, head, dstPos, 2);
			dstPos+=2;
			//参数
			if(data != null){
				System.arraycopy(data, 0, head, dstPos, data.length);
			}

			byte[] bytes = getQhProtocol808(head, 0x0104);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 录音文件查询应答
	 * @param result  结果 0 查询成功 1车载设备不支持当前操作（已有一个调取录音操作）
	 * @param count 查询到录音文件总数 如果录音文件总数为0，未查询到录音，将无后续项
	 * @return
	 */
	public byte[] queryRecordingFileAnswer(int result,int count){
		try {
			byte[] bytes = new byte[3];
			int dstPos = 0;
			//录音文件总数
			System.arraycopy(Tools.int2Bytes(result, 1), 0, bytes, dstPos, 1);
			dstPos +=1;

			System.arraycopy(Tools.int2Bytes(count, 2), 0, bytes, dstPos, 2);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 录音文件信息
	 * @param filesum 文件总数
	 * @param format 录音文件格式
	 * @param packsum 数据包总数
	 * @param packid 数据包ID
	 * @param filedata 录音数据
	 * @return
	 */
	public byte[] getRecordingFile(int filesum,int format,int packsum,int packid,byte[] filedata){
		try {
			int len = 0;
			if(filedata==null){
				len = 7;
			}else{
				len = 7+filedata.length;
			}
			byte[] bytes = new byte[len];
			int dstPos = 0;
			//录音文件总数
			System.arraycopy(Tools.int2Bytes(filesum, 2), 0, bytes, dstPos, 2);
			dstPos +=2;

			System.arraycopy(Tools.int2Bytes(format, 1), 0, bytes, dstPos, 1);
			dstPos +=1;

			System.arraycopy(Tools.int2Bytes(packsum, 2), 0, bytes, dstPos, 2);
			dstPos +=2;

			System.arraycopy(Tools.int2Bytes(packid, 2), 0, bytes, dstPos, 2);
			dstPos +=2;
			if(filedata!=null){
				System.arraycopy(filedata, 0, bytes, dstPos, filedata.length);
			}
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 录音数据上传编码
	 * @param recordingFile 录音文件
	 * @return
	 */
	//	public byte[] getRecordingData(RecordingFile recordingFile){
	//		try {
	//
	//			byte[] bytes = new byte[18+recordingFile.getPackdata().length];
	//
	//			int dstPos = 0;
	//
	//			System.arraycopy(Tools.int2Bytes(recordingFile.getFilesum(), 2), 0, bytes, dstPos, 2);
	//			dstPos +=2;
	//
	//			System.arraycopy(Tools.int2Bytes(recordingFile.getCurrent(), 2), 0, bytes, dstPos, 2);
	//			dstPos +=2;
	//
	//			System.arraycopy(Tools.str2Bcd(recordingFile.getFilename()), 0, bytes, dstPos, 6);
	//			dstPos +=6;
	//
	//			System.arraycopy(Tools.int2Bytes(recordingFile.getFormat(), 2), 0, bytes, dstPos, 2);
	//			dstPos +=2;
	//
	//			System.arraycopy(Tools.int2Bytes(recordingFile.getPacksum(), 2), 0, bytes, dstPos, 2);
	//			dstPos +=2;
	//
	//			System.arraycopy(Tools.int2Bytes(recordingFile.getPackid(), 2), 0, bytes, dstPos, 2);
	//			dstPos +=2;
	//
	//			System.arraycopy(Tools.int2Bytes(recordingFile.getPackdata().length, 2), 0, bytes, dstPos, 2);
	//			dstPos +=2;
	//
	//			System.arraycopy(recordingFile.getPackdata(), 0, bytes, dstPos, recordingFile.getPackdata().length);
	//
	//			return bytes;
	//
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 编码计价器开钥匙门信息上传协议
	 * @param driverInfo
	 * @return
	 */
	//	public byte[] meterOpenKeyDoor(TaximeterDriverInfo driverInfo){
	//		try {
	//			if(driverInfo != null){
	//				byte [] carnumber = (driverInfo.getCarNumber()+"\0").getBytes("GBK");
	//				int len = carnumber.length;
	//				byte[] body = new byte[21+len];
	//				int dstPos = 0;
	//				//车牌号
	//				System.arraycopy(carnumber, 0, body, dstPos, len);
	//				dstPos +=len;
	//				//PSAM卡号
	//				System.arraycopy(Tools.str2Bcd(driverInfo.getPSAMCardCode()), 0, body, dstPos, 6);
	//				dstPos +=6;
	//
	//				//计价器设备号
	//				int taximeterCode = 0;
	//				if(driverInfo.getTaximeterCode() != null){
	//					taximeterCode = Integer.parseInt(driverInfo.getTaximeterCode());
	//				}
	//				System.arraycopy(Tools.sortToByte(Tools.int2Bytes(taximeterCode, 4)), 0, body, dstPos, 4);
	//				dstPos +=4;
	//				//司机标识号
	//				int driverID = 0;
	//				if(driverInfo.getDriverID() != null){
	//					driverID = Integer.parseInt(driverInfo.getDriverID());
	//				}
	//				System.arraycopy(Tools.sortToByte(Tools.int2Bytes(driverID, 4)), 0, body, dstPos, 4);
	//				dstPos +=4;
	//				//卡类型生成日期
	//				System.arraycopy(Tools.str2Bcd(driverInfo.getCardTypeDate()), 0, body, dstPos, 3);
	//				dstPos +=3;
	//
	//				//黑名单版本号
	//				int blackListVer = 0;
	//				if(driverInfo.getBlackListVersion() != null){
	//					blackListVer = Integer.parseInt(driverInfo.getBlackListVersion());
	//				}
	//				System.arraycopy(Tools.sortToByte(Tools.int2Bytes(blackListVer, 2)), 0, body, dstPos, 2);
	//				dstPos +=2;
	//
	//				//软件版本号
	//				int softwareVer = 0;
	//				if(driverInfo.getSoftwareVersion() != null){
	//					softwareVer = Integer.parseInt(driverInfo.getSoftwareVersion());
	//				}
	//				System.arraycopy(Tools.sortToByte(Tools.int2Bytes(softwareVer, 2)), 0, body, dstPos, 2);
	//				dstPos +=2;
	//				byte[] bytes = getQhProtocol808(body, 0x5108);
	//				return bytes;
	//			}
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//		return null;
	//	}

	/**
	 * 编码事件报告 0x0301
	 * @param eventid 事件ID
	 * @return
	 */
	public byte[] getEventReport(int eventid){
		try {
			byte[] body = new byte[1];
			int dstPos = 0;
			//事件ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(eventid, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			byte[] bytes = getQhProtocol808(body, 0x0301);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 提问应答 0x0302
	 * @param questionId 问题ID
	 * @param answerid 答案ID
	 * @return
	 */
	public byte[] questionAnswer(int questionId, int answerid){
		try {
			byte[] body = new byte[5];
			int dstPos = 0;
			// 问题ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(questionId, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			// 答案ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(answerid, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			byte[] bytes = getQhProtocol808(body, 0x0302);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 文本信息应答 0x0305
	 * 如果顶灯没有任何信息，则返回一个编号为0的文本信息应答消息。
	 * @param flag 标志
	 * @param serial 当前序号
	 * @param text 文本信息
	 * @return
	 */
	public byte[] textAnswer(int flag,int serial,String text){
		try {
			byte[] textbyte = (text+"\0").getBytes("GBK");
			byte[] body = new byte[2+textbyte.length];
			int dstPos = 0;

			//标志
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(flag, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			//当前序号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(serial, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			//文本信息
			System.arraycopy(textbyte, 0, body, dstPos,textbyte.length);
			dstPos +=textbyte.length;

			byte[] bytes = getQhProtocol808(body, 0x0305);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 车辆控制应答
	 * @param reseq 应答流水号
	 * @return
	 */
	public byte[] vehicleControlAnswer(int reseq){
		try {
			//位置数据
			byte [] locationbyte = EncoderUtil.getLocationInformationByte();
			byte[] body = new byte[2+locationbyte.length];
			int dstPos = 0;
			//应答流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reseq, 2)), 0, body, dstPos, 2);
			dstPos +=2;

			//位置数据
			System.arraycopy(locationbyte, 0, body, dstPos, locationbyte.length);
			dstPos +=locationbyte.length;

			byte[] bytes = getQhProtocol808(body, 0x0500);
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 摄像头图像上传
	 * @param reason  上传原因 	终端主动拍照：0		平台命令或检索：对应命令流水号
	 * @param mdataid  图像ID
	 * @param chid 通道 ID	在此默认为0
	 * @param fileSize 位置图像数据大小
	 * @param pkgNum  起始地址	uint32	第一包为0
	 * @param data 位置图像数据包
	 * @return
	 */
	public byte[] multimediaDataUpload(int reason, int mdataid, int chid, int fileSize, int pkgNum, byte[] fileHead, byte[] data){
		try {
			AppLog.i("照片大小:"+fileSize+"; 当前偏移量:"+pkgNum);
			int len = 15;
			if(data != null){
//				if(pkgNum == 0){
//					len += (data.length + 128);
//				}else{
				len += data.length;
//				}
			}

			byte[] body = new byte[len];
			int dstPos = 0;

			//上传原因 	uint16		终端主动拍照：0		平台命令或检索：对应命令流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reason, 2)), 0, body, dstPos, 2);
			dstPos +=2;

			//多媒体数据ID		uint32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(mdataid, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//通道 ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(chid, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			//位置图像数据大小		uint32
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(fileSize, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//起始地址		uint32	第一包为0
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgNum, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			// 数据
			if(data != null){
//				if(pkgNum == 0 && fileHead != null){
//					System.arraycopy(fileHead, 0, body, dstPos, fileHead.length);
//					dstPos += 128;
//				}
				System.arraycopy(data, 0, body, dstPos, data.length);
			}

			byte[] bytes = getQhProtocol808(body, 0x0800);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}


	/**
	 * 3.2.40	多媒体检索应答(每次只返回一个检索项)
	 * @param reseq 应答流水号 		对应检索命令流水号
	 * @param pkgCount 多媒体数据总项数	X4
	 * @param pkgNum 包序号	第一包为0
	 * @param data 数据
	 * @return
	 */
	public byte[] multimediaRetrievalResponse(int reseq, int pkgCount, int pkgNum, byte[] data){
		try {

			int len = 10;
			if(data != null){
				len += data.length;
			}

			byte[] body = new byte[len];
			int dstPos = 0;

			//应答流水号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reseq, 2)), 0, body, dstPos, 2);
			dstPos +=2;

			//多媒体数据总项数	X4
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reseq, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//包序号	第一包为0
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reseq, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//数据
			if(data != null){
				System.arraycopy(data, 0, body, dstPos, data.length);
			}

			byte[] bytes = getQhProtocol808(body, 0x0802);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 存储图像上传命令
	 * @param type 		文件类型	0：照片	1：音频	2：视频		RFU：其他
	 * @param mediaId	文件ID
	 * @param pkgNum	起始地址
	 * @return
	 */
	public byte[] multiMediaData(int type, int mediaId, int pkgNum){
		try {
			//位置数据
			byte[] body = new byte[9];
			int dstPos = 0;

			//文件类型
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(type, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			//文件ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(mediaId, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			//起始地址
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgNum, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			byte[] bytes = getQhProtocol808(body, 0x0803);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 存储音视频检索应答
	 * @param serialId	检索命令流水号
	 * @param timeData	时间段信息
	 * @return
	 */
	//	public byte[] mediaSearchResponder(int serialId, ArrayList<MediaTimeEntity> timeData){
	//		try {
	//			int len = 3;
	//			if(timeData != null && timeData.size() != 0){
	//				len += timeData.size() * 10;
	//			}
	//			byte[] body = new byte[len];
	//			int dstPos = 0;
	//
	//			//文件类型
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(serialId, 2)), 0, body, dstPos, 2);
	//			dstPos +=2;
	//
	//			//时间段总数
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(timeData.size(), 1)), 0, body, dstPos, 1);
	//			dstPos +=1;
	//
	//			if(len > 3){
	//				for(int i = 0;i<timeData.size();i++){
	//					MediaTimeEntity timeEntity = timeData.get(i);
	//					// 通道号
	//					System.arraycopy(Tools.sortToByte(Tools.int2Bytes(timeEntity.getChannelId(), 1)), 0, body, dstPos, 1);
	//					dstPos +=1;
	//					// 日期
	//					System.arraycopy(Tools.str2Bcd(timeEntity.getDate()), 0, body, dstPos, 3);
	//					dstPos +=3;
	//					// 开始时间
	//					System.arraycopy(Tools.str2Bcd(timeEntity.getStartTime()), 0, body, dstPos, 3);
	//					dstPos +=3;
	//					// 结束时间
	//					System.arraycopy(Tools.str2Bcd(timeEntity.getEndTime()), 0, body, dstPos, 3);
	//					dstPos +=3;
	//				}
	//			}
	//
	//			byte[] bytes = getQhProtocol808(body, 0x0807);
	//			return bytes;
	//
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 存储音视频检索应答
	 * @param serialId	检索命令流水号
	 * @param timeData	时间段信息
	 * @return
	 */
	//	public byte[] mediaSearchResponder(byte[] data){
	//		try {
	//			byte[] body = new byte[2+data.length];
	//			int dstPos = 0;
	//
	//			//流水号
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(RecorderBiz.serialId8807, 2)), 0, body, dstPos, 2);
	//			dstPos += 2;
	//			// 录像机回传数据
	//			System.arraycopy(data, 0, body, dstPos, data.length);
	//			dstPos += data.length;
	//
	//			byte[] bytes = getQhProtocol808(body, 0x0807);
	//			return bytes;
	//
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 存储音视频检回放状态通知
	 * @param channelId	音视频通道号
	 * @return
	 */
	public byte[] mediaBackPlayState(int channelId){
		try {
			byte[] body = new byte[4];
			int dstPos = 0;

			// 音视频通道号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(channelId, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			byte[] bytes = getQhProtocol808(body, 0x0809);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 存储音视频检上传状态通知
	 * @param fileName	文件名
	 * @param flag	0：开始上次	1：传输过程中	2：上传完成	3：上传失败	4：FTP连接失败		5：平台主动取消
	 * @param fileSize	文件总字节数
	 * @param loadedSize	已上传字节数
	 * @return
	 */
	public byte[] mediaUploadState(String fileName, int flag, int fileSize, int loadedSize){
		try {

			byte[] file = (fileName+"\0").getBytes("GBK");

			byte[] body = new byte[49 + file.length];
			int dstPos = 0;

			// 文件名
			System.arraycopy(file, 0, body, dstPos, file.length);
			dstPos +=file.length;
			// 上传起始标识
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(flag, 1)), 0, body, dstPos, 1);
			dstPos +=1;
			// 文件大小
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(fileSize, 4)), 0, body, dstPos, 4);
			dstPos +=4;
			// 已上传大小
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(loadedSize, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			byte[] bytes = getQhProtocol808(body, 0x080B);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 存储音视频检上传状态通知
	 * @return
	 */
	public byte[] mediaUploadState(byte[] data){
		try {

			byte[] bytes = getQhProtocol808(data, 0x080B);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 实时音视频媒体通道注册
	 * @return
	 */
	public byte[] mediaRegister(int channleID, int streamType, int dataType){
		try {

			byte[] body = new byte[28];
			int dstPos = 0;


			// 0	终端ID号	BCD[7]	MCU终端的ID号
			System.arraycopy(Tools.str2Bcd(DeviceBiz.getDeviceCode()), 0, body, dstPos, 6);
			dstPos+=7;

			//车牌颜色
			dstPos+=1;

			// 6	车牌号	STRING[16]	车牌号，不足长度以’\0’填充
			String carNumber = DeviceBiz.getCarNumber();
			while(carNumber.length()<16){
				carNumber += "\0";
			}
			byte[] carNumberByte = carNumber.getBytes("GBK");
			System.arraycopy(carNumberByte, 0, body, dstPos, carNumberByte.length);
			dstPos+=16;

			//逻辑通道号
			System.arraycopy(Tools.int2Bytes2(channleID, 1), 0, body, dstPos, 1);
			dstPos+=1;
			//码流类型
			System.arraycopy(Tools.int2Bytes2(streamType, 1), 0, body, dstPos, 1);
			dstPos+=1;
			//数据类型
			System.arraycopy(Tools.int2Bytes2(dataType, 1), 0, body, dstPos, 1);
			dstPos+=1;
			//视频类型
			System.arraycopy(Tools.int2Bytes2(0, 1), 0, body, dstPos, 1);
			dstPos+=1;

			byte[] bytes = getQhProtocol808(body, 0x1209);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}


	/**
	 * 实时音视频媒体通道注册
	 * @return
	 */
	public int zhenid = 0;//帧序号，每次打开媒体通道注册后，要重置为0
	public long time_rtp = 0;//相对时间，每次打开媒体通道注册后，要重置为0
	public synchronized byte[] getmediaRtp(byte[] data){
		try {

			byte[] body = new byte[26+data.length];
			int dstPos = 0;


			// 帧头标识    30 31 63 64
			System.arraycopy(Tools.parseHexStr2Byte("30 31 63 64"), 0, body, dstPos, 4);
			dstPos+=4;

			//包序号
			dstPos+=2;

			// 帧序号
			System.arraycopy(Tools.int2Bytes2(zhenid, 2), 0, body, dstPos, 2);
			dstPos+=2;
			zhenid++;

			//数据类型
			System.arraycopy(Tools.int2Bytes2(3, 1), 0, body, dstPos, 1);
			dstPos+=1;

			//负载类型
//			System.arraycopy(Tools.int2Bytes2(23, 1), 0, body, dstPos, 1);//pcm
			System.arraycopy(Tools.int2Bytes2(6, 1), 0, body, dstPos, 1);//g711a
			dstPos+=1;

			//相对时间
			if(time_rtp==0){
				time_rtp = System.currentTimeMillis();
			}
			System.arraycopy(Tools.int2Bytes2((int) (System.currentTimeMillis()-time_rtp), 8), 0, body, dstPos, 8);
			dstPos+=8;

			//绝对时间
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, body, dstPos, 6);
			dstPos+=6;

			//数据长度
			System.arraycopy(Tools.int2Bytes2(data.length, 2), 0, body, dstPos, 2);
			dstPos+=2;

			//数据
			System.arraycopy(data, 0, body, dstPos, data.length);

			AppLog.e("音频数据："+Tools.parseByte2HexStr(data));
			AppLog.e("打包数据："+Tools.parseByte2HexStr(body));

			return body;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 终端上传音视频资源列表
	 * @return
	 */
	//	public byte[] mediaDataListUpload(byte[] videoData){
	//		try {
	//
	//			byte[] body = new byte[2+videoData.length];
	//			int dstPos = 0;
	//
	//			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(RecorderBiz.serialId9505, 2)), 0, body, dstPos, 2);
	//			dstPos += 2;
	//
	//			System.arraycopy(videoData, 0, body, dstPos, videoData.length);
	//			dstPos += videoData.length;
	//
	//			byte[] bytes = getQhProtocol808(body, 0x1505);
	//			return bytes;
	//
	//		} catch (Exception e) {
	//			AppLog.e(ExceptionUtil.getInfo(e));
	//			e.printStackTrace();
	//			return null;
	//		}
	//	}

	/**
	 * 设备巡检应答
	 * @return
	 */
	public byte[] inspectionResponse(){
		try {


			byte[] body = new byte[49];
			int dstPos = 0;

			// 上传起始标识
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(1, 1)), 0, body, dstPos, 1);
			dstPos +=1;

			byte[] bytes = getQhProtocol808(body, 0x0B11);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 音视频流媒体服务器注册
	 * @param channelId		多媒体数据ID
	 * @return
	 */
	public byte[] mediaRegister(int channelId){
		try {
			byte[] body = new byte[4];
			int dstPos = 0;

			// 已上传大小
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(channelId, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			byte[] bytes = getQhProtocol808(body, 0x0804);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 数据盲区补传
	 * @param locationHexStr
	 * @return
	 */
	public byte[] locationInfoReload(ArrayList<String> locationHexStr){
		try {
			int dstPos = 0;
			int subLen = Tools.parseHexStr2Byte(locationHexStr.get(0)).length;
			byte[] body = new byte[subLen * locationHexStr.size()];

			for(int i = 0;i<locationHexStr.size();i++){
				System.arraycopy(Tools.parseHexStr2Byte(locationHexStr.get(i)), 0, body, dstPos, subLen);
				dstPos += subLen;
			}

			byte[] bytes = getQhProtocol808(body, 0x0203);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 出租车司机卡黑名单信息查询
	 * @param version	版本号	YYMMDD,终端本机黑名单版本号，000000表示当前五黑名单
	 * @param type		下载类型	0：基本库下载	1：增量库下载
	 * @param compress	是否支持数据压缩	0：不支持	1：支持
	 * @param arithmetic	支持数据压缩算法	0：无	1：gz；.....
	 * @param pkgId		请求包ID， 从1开始
	 * @return
	 */
	public byte[] driverBlackInfoDownload(String version, int type, int compress, int arithmetic, int pkgId){
		try {
			int dstPos = 0;
			byte[] body = new byte[10];

			// 版本号
			System.arraycopy(Tools.str2Bcd(version), 0, body, dstPos, 3);
			dstPos +=3;
			// 下载类型
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(type, 1)), 0, body, dstPos, 1);
			dstPos +=1;
			// 是否支持数据压缩
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(compress, 1)), 0, body, dstPos, 1);
			dstPos +=1;
			// 支持数据压缩算法
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(arithmetic, 1)), 0, body, dstPos, 1);
			dstPos +=1;
			// 请求包ID
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgId, 4)), 0, body, dstPos, 4);
			dstPos +=4;

			byte[] bytes = getQhProtocol808(body, 0x0B50);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 出租车司机卡黑名单信息下载响应
	 * @return
	 */
	public byte[] qureyDriverBlackInfo(){
		try {
			byte[] body = new byte[0];
			byte[] bytes = getQhProtocol808(body, 0x0B51);
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 组装消息头
	 * @param phone
	 * @param msgid
	 * @param uDataByte
	 * @return
	 */
	public byte[] getMsghead808(String phone,int msgid,byte[] uDataByte){

		int uDataLen = 0;
		if(uDataByte!=null){
			uDataLen = uDataByte.length;
		}

		//消息头
		byte[] msghead = new byte[12];
		int headnum = 0;
		//消息ID
		System.arraycopy(Tools.sortToByte(Tools.int2Bytes(msgid,2)), 0, msghead, headnum, 2);
		headnum +=2;
		//消息体属性
		System.arraycopy(Tools.sortToByte(Tools.int2Bytes(uDataLen, 2)), 0, msghead, headnum, 2);
		headnum +=2;

		//终端手机号
		System.arraycopy(Tools.str2Bcd(phone), 0, msghead, headnum,6);
		headnum +=6;

		//消息流水号
		byte[] serialId = Tools.sortToByte(Tools.int2Bytes(getSerialId(),2));
		//		System.out.println("-----------消息流水号:"+Tools.bytesToHexString(serialId));
		System.arraycopy(serialId, 0, msghead, headnum, 2);
		return msghead;
	}

	/**
	 * 组装分包的消息头
	 * @param phone
	 * @param msgid
	 * @param uDataByte
	 * @param pkgCount	消息总包数
	 * @param pkgNum	包序号
	 * @return
	 */
	public byte[] getMsghead808Subpackage(String phone,int msgid,byte[] uDataByte, int pkgCount, int pkgNum){

		int uDataLen = 0;
		if(uDataByte!=null){
			uDataLen = uDataByte.length;
		}

		//消息头
		byte[] msghead = new byte[16];
		int headnum = 0;
		//消息ID
		System.arraycopy(Tools.sortToByte(Tools.int2Bytes(msgid,2)), 0, msghead, headnum, 2);
		headnum +=2;
		//消息体属性
		String attribute = StringUtil.getAntitone(Tools.byteTobit(Tools.sortToByte(Tools.int2Bytes(uDataLen, 2))));
		// 添加分包标记
		attribute = StringUtil.replaceIndex(13, attribute, "1");
		attribute = StringUtil.getAntitone(attribute);
		byte[] attrib = new byte[2];
		attrib[0] = Tools.BitToByte(attribute.substring(0, 8));
		attrib[1] = Tools.BitToByte(attribute.substring(8, 16));

		System.arraycopy(attrib, 0, msghead, headnum, 2);
		headnum +=2;

		//终端手机号
		System.arraycopy(Tools.str2Bcd(phone), 0, msghead, headnum,6);
		headnum +=6;

		//消息流水号
		byte[] serialId = Tools.sortToByte(Tools.int2Bytes(getSerialId(),2));
		Log.d(TAG,"-----------消息流水号:" + Tools.bytesToHexString(serialId));
		System.arraycopy(serialId, 0, msghead, headnum, 2);
		headnum +=2;

		//消息包封装项

		// 消息总包数	WORD	该消息分包后的总包数
		System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgCount, 2)), 0, msghead, headnum, 2);
		headnum +=2;
		// 包序号	WORD	从1开始
		System.arraycopy(Tools.sortToByte(Tools.int2Bytes(pkgNum, 2)), 0, msghead, headnum, 2);
		headnum +=2;
		return msghead;
	}

	/**
	 * 组装效验码
	 * @param msghead
	 * @param dataByte
	 * @return
	 */
	public byte[] getCheckCode(byte[] msghead,byte[] dataByte){
		int dataLen = 0;
		if(dataByte != null){
			dataLen = dataByte.length;
		}
		//---校验码
		byte[] checkcode = new byte[msghead.length+dataLen];
		int num = 0;
		System.arraycopy(msghead, 0, checkcode, num, msghead.length);
		num+=msghead.length;
		if(dataByte!=null){
			System.arraycopy(dataByte, 0, checkcode, num, dataLen);
		}
		return checkcode;
	}

	/**
	 * 按照国标808协议编码
	 * @param dataByte
	 * @param msgid 消息ID
	 * @return
	 */
	public byte[] getQhProtocol808(byte[] dataByte,int msgid){

		String phone = SPUtils.getParamString(SPConstants.SPK_clientcode, SPConstants.SPV_clientcode);

		int uDataLen = 0;

		//消息头组装
		byte[] msghead = getMsghead808(phone, msgid, dataByte);

		//校验码
		byte[] checkcode = getCheckCode(msghead, dataByte);

		//消息头转义
		msghead = tropeYXByte(Tools.parseByte2HexStr(msghead));

		//校验码转义
		checkcode = tropeYXByte(Tools.parseByte2HexStr(Tools.byteOrbyte(checkcode)));

		if(dataByte!=null){
			//消息体转义
			dataByte = tropeYXByte(Tools.parseByte2HexStr(dataByte));
			uDataLen = dataByte.length;
		}

		byte[] bodybyte =  new byte[msghead.length+uDataLen+checkcode.length+2];
		try {
			int dstPos = 0;
			//--起始位
			System.arraycopy(Tools.parseHexStr2Byte("7e"), 0, bodybyte, dstPos, 1);
			dstPos +=1;

			//--消息头
			System.arraycopy(msghead, 0, bodybyte, dstPos, msghead.length);
			dstPos +=msghead.length;

			//---消息体
			if(dataByte!=null){
				System.arraycopy(dataByte, 0, bodybyte, dstPos, dataByte.length);
				dstPos +=dataByte.length;
			}

			//校验码
			System.arraycopy(checkcode, 0, bodybyte, dstPos, checkcode.length);
			dstPos +=checkcode.length;

			//---结束位
			System.arraycopy(Tools.parseHexStr2Byte("7e"), 0, bodybyte, dstPos, 1);

			//			System.out.println("组装完整消息包-"+ Tools.parseByte2HexStr(bodybyte));
			return bodybyte;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 国标808协议编码分包
	 * @param dataByte
	 * @param msgid 消息ID
	 * @return
	 */
	public byte[] getQhProtocol808Subpackage(byte[] dataByte,int msgid, int pkgCount, int pkgNum){

		String phone = SPUtils.getParamString(SPConstants.SPK_clientcode, SPConstants.SPV_clientcode);

		int uDataLen = 0;

		//消息头组装
		byte[] msghead = getMsghead808Subpackage(phone, msgid, dataByte, pkgCount, pkgNum);

		//校验码
		byte[] checkcode = getCheckCode(msghead, dataByte);

		//消息头转义
		msghead = tropeYXByte(Tools.parseByte2HexStr(msghead));

		//校验码转义
		checkcode = tropeYXByte(Tools.parseByte2HexStr(Tools.byteOrbyte(checkcode)));

		if(dataByte!=null){
			//消息体转义
			dataByte = tropeYXByte(Tools.parseByte2HexStr(dataByte));
			uDataLen = dataByte.length;
		}

		byte[] bodybyte =  new byte[msghead.length+uDataLen+checkcode.length+2];
		try {
			int dstPos = 0;
			//--起始位
			System.arraycopy(Tools.parseHexStr2Byte("7e"), 0, bodybyte, dstPos, 1);
			dstPos +=1;

			//--消息头
			System.arraycopy(msghead, 0, bodybyte, dstPos, msghead.length);
			dstPos +=msghead.length;

			//---消息体
			if(dataByte!=null){
				System.arraycopy(dataByte, 0, bodybyte, dstPos, dataByte.length);
				dstPos +=dataByte.length;
			}

			//校验码
			System.arraycopy(checkcode, 0, bodybyte, dstPos, checkcode.length);
			dstPos +=checkcode.length;

			//---结束位
			System.arraycopy(Tools.parseHexStr2Byte("7e"), 0, bodybyte, dstPos, 1);

			System.out.println(Tools.parseByte2HexStr(bodybyte));
			return bodybyte;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 上报终端功能使用次数
	 * @param countData
	 * @return
	 */
	public byte[] getUsePrefCount(String countData){
		try {
			byte[] head = Tools.stringToByte(countData);

			byte[] bytes = getQhProtocol808(head, 0x510A);

			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}



	/*******************************************电召业务开始******************************************************/

	/**
	 * 抢答
	 * @param orderid 业务ID	BCD[6]	中心生成的业务ID
	 * @return
	 */
	public byte[] getCallInstructionAnswer(int orderid){
		try {
			//数据内容
			byte[] data = new byte[4];
			int dstPos = 0;
			// 订单号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(orderid, 4)), 0, data, dstPos, 4);
			dstPos += 4;
			//处理整个消息
			byte[] bytes = getQhProtocol808(data,0x0b01);
			AppLog.v("抢答信息:"+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.44	订单接受
	 * @param orderid 业务ID	BCD[6]	中心生成的业务ID
	 * @param orderid 结果	UINT8	1：接受成功 	2：接受失败（已转重车等原因）
	 * @return
	 */
	public byte[] getOrderAccept(String orderid, int result){
		try {
			//数据内容
			byte[] data = new byte[13];
			int dstPos = 0;
			// 订单号
			System.arraycopy(Tools.str2Bcd(orderid), 0, data, dstPos, 6);
			dstPos += 6;
			// 结果
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(result, 1)), 0, data, dstPos, 1);
			dstPos += 1;
			// 时间
			System.arraycopy(Tools.str2Bcd(DateUtil.getTodayDate(DateUtil.df8)), 0, data, dstPos, 6);
			//处理整个消息
			byte[] bytes = getQhProtocol808(data,0x0b02);
			AppLog.v("订单接受信息:"+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 电召中心处理结果应答
	 * @param orderid 定单号	String
	 * @param result 处理结果	BYTE	0x01成功 0x02失败
	 * @return
	 */
	public byte[] getCallCenterProcessingResultsAnswer(String orderid,int result){

		try {
			byte[] orderidByte = (orderid+"\0").getBytes();
			//数据内容
			byte[] data = new byte[orderidByte.length + 1];
			int dstPos = 0;
			// 订单号
			System.arraycopy(orderidByte, 0, data, dstPos, orderidByte.length);
			dstPos += orderidByte.length;
			// 处理结果
			System.arraycopy(Tools.longToByteOne(result), 0, data, dstPos, 1);

			//处理整个消息
			byte[] bytes = getQhProtocol808(data,0x5105);
			AppLog.v("电召中心处理结果应答:"+Tools.parseByte2HexStr(bytes));
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 3.2.46	订单完成
	 * @param orderId		订单号
	 * @return
	 */
	public byte[] getCallInstructionResultsDoc(String orderId){

		try {
			byte[] data = new byte[4];
			int dstPos = 0;
			//订单号
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(
					Integer.parseInt(orderId), 4)), 0, data, dstPos, 4);
			dstPos += 4;

			//处理整个消息
			byte[] bytes = getQhProtocol808(data,0x0b07);
			AppLog.v("执行电召:"+Tools.parseByte2HexStr(bytes));
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}


	/**
	 * 司机取消电召
	 * @param orderid 定单号	uint32
	 * @param reason 取消原因	BYTE	0x00 事故   0x01 堵路   0x02 其他
	 * @return
	 */
	public byte[] getCancelByte(int orderid,int reason){

		try {
			int dstPos = 0;
			//数据内容
			byte[] data = new byte[5];
			//orderId
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(orderid, 4)), 0, data, dstPos, 4);
			dstPos +=4;
			// 处理结果
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(reason,1)), 0, data, dstPos, 1);

			//处理整个消息
			byte[] bytes = getQhProtocol808(data,0x0B08);
			AppLog.v("司机取消电召:"+Tools.parseByte2HexStr(bytes));
			return bytes;

		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/*******************************************电召业务结束******************************************************/


	/**
	 * 日使用上报
	 * @param time			统计时间	BCD[6]	YY-MM-DD-hh-mm-ss (GMT+8时间，本标准之后涉及的时间均采用此时区)
	 * @param function		功能类型	Byte	1 	考拉FM
	 * @param count			使用次数	DWORD	次
	 * @param duration		使用时长	DWORD	秒
	 * @param flow			使用流量	DWORD	Kb / 默认为0
	 * @return
	 */
	public byte[] getDailyUsage(String time, int function, int count, long duration, long flow){
		try {
			//数据内容
			byte[] body = new byte[15];
			int dstPos = 0;

			//统计时间
			System.arraycopy(Tools.str2Bcd(time), 0, body, dstPos, 6);
			dstPos +=6;

			//功能类型
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(function,1)), 0, body, dstPos, 1);
			dstPos+=1;

			//使用次数
			System.arraycopy(Tools.sortToByte(Tools.int2Bytes(count,4)), 0, body, dstPos, 4);
			dstPos+=4;

			//使用时长
			System.arraycopy(Tools.sortToByte(Tools.longToByteOne(duration)), 0, body, dstPos, 4);
			dstPos+=4;

			//流量
			System.arraycopy(Tools.sortToByte(Tools.longToByteOne(flow)), 0, body, dstPos, 4);
			dstPos+=4;

			//处理整个消息
			byte[] bytes = getQhProtocol808(body,0x5104);
			AppLog.v("抢答信息:"+Tools.parseByte2HexStr(bytes));
			return bytes;
		} catch (Exception e) {
			AppLog.e(ExceptionUtil.getInfo(e));
			e.printStackTrace();
			return null;
		}
	}

	/**
	 *  7EH 《————》 7DH+02H；
	 *  7DH 《————》 7DH+01H；
	 * @param str 16 进制
	 * @return
	 */
	public byte[] tropeYXByte(String str){
		return ByteArrayUtil.reverse808Send(Tools.parseHexStr2Byte(str));
	}
}
